home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / Class.C < prev    next >
C/C++ Source or Header  |  1992-06-09  |  4KB  |  200 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "Class.h"
  6.  
  7. #include "Error.h"
  8. #include "Storage.h"
  9. #include "String.h"
  10. #include "ObjArray.h"
  11. #include "OrdColl.h"
  12. #include "ObjectTable.h"
  13. #include "ClassManager.h"
  14. #include "AccessMem.h"
  15.  
  16. //---- Class -------------------------------------------------------------------
  17.  
  18. NewMetaImpl(Class,Object, (TP(version), TP(super), TP(className), T(size),
  19.     TP(proto), TS(declFileName), T(declFileLine), TS(implFileName),
  20.     T(implFileLine), TP(subclasses), T(instanceCount), TP(methods)));
  21.  
  22. Class *Class::classptr;
  23.  
  24. #ifdef ET_
  25.     static char *EtPrefix= _QUOTE_(ET_);
  26. #else
  27.     static char *EtPrefix= "";
  28. #endif
  29.  
  30. Class::Class(char *name, int sz, Object *pro, char *implfn, char *declfn,
  31.                         int il, int dl, bool abstract)
  32. {
  33.     size= sz;
  34.     className= name;
  35.     if (strncmp(name, EtPrefix, sizeof(EtPrefix)-1) == 0) 
  36.     className= &name[sizeof(EtPrefix)-1];
  37.     declFileName= declfn;
  38.     implFileName= implfn;
  39.     declFileLine= dl;
  40.     implFileLine= il;
  41.     proto= pro;
  42.     subclasses= 0;
  43.     instanceCount= 0;
  44.     methods= 0;
  45.     version= "2.2";
  46.     if (abstract)
  47.     SetFlag(eClassAbstract);
  48.     if (gClassManager == 0)
  49.     gClassManager= new ClassManager;
  50.     gClassManager->Add(this);
  51.     if (proto)
  52.     SetFlag(eClassObject);
  53.     classptr= 0;
  54. }
  55.  
  56. Class::Class(char *name, char *vers)
  57. {
  58.     className= name;
  59.     version= vers;
  60.     proto= 0;
  61.     methods= 0;
  62.     subclasses= 0;
  63. }
  64.  
  65. Class::~Class()
  66. {
  67.     if (proto) {
  68.     delete (void*) proto;        // avoid call of destructor for prototype
  69.     proto= 0;
  70.     }
  71.     if (methods) {
  72.     methods->FreeAll();
  73.     SafeDelete(methods);
  74.     }
  75.     SafeDelete(subclasses);
  76.     if (gClassManager)
  77.     gClassManager->Remove(this);
  78. }
  79.  
  80. //---- class hierarchy ---------------------------------------------------------
  81.  
  82. Class *Class::SetSuper()
  83. {
  84.     super= classptr;
  85.     classptr= this;
  86.     return this;
  87. }
  88.  
  89. bool Class::isKindOf(register Class *c)
  90. {
  91.     register Class *cc;
  92.  
  93.     for (cc= this; cc; cc= cc->super)
  94.     if (cc == c)
  95.         return TRUE;
  96.     return FALSE;
  97. }
  98.  
  99. void Class::AddSubclass(Class *cl)
  100. {
  101.     if (subclasses == 0)
  102.     subclasses= new OrdCollection;
  103.     subclasses->Add(cl);
  104. }
  105.  
  106. Iterator *Class::SubclassIterator()
  107. {
  108.     if (subclasses == 0)
  109.     subclasses= new OrdCollection;
  110.     return subclasses->MakeIterator();
  111. }
  112.  
  113. //---- comparing ---------------------------------------------------------------
  114.  
  115. u_long Class::Hash()
  116. {
  117.     register u_long hash;
  118.     register char *p= className;
  119.  
  120.     for (hash= 0; *p; p++)
  121.     hash= (hash << 1) ^ *p;
  122.     return hash;
  123. }
  124.  
  125. bool Class::IsEqual(Object *op)
  126. { 
  127.     //return strcmp(className, ((Class*)op)->className) == 0
  128.     //            && strcmp(version, ((Class*)op)->version) == 0;
  129.     return strcmp(className, ((Class*)op)->className) == 0;
  130. }
  131.  
  132. int Class::Compare(Object *op)
  133. {
  134.     //int rc= strcmp(className, ((Class*)op)->className);
  135.     //if (rc)
  136.     //    return rc;
  137.     //return strcmp(version, ((Class*)op)->version);
  138.     return strcmp(className, ((Class*)op)->className);
  139. }
  140.  
  141. //---- converting, input/output ------------------------------------------------
  142.  
  143. char* Class::AsString()
  144. {
  145.     return className;
  146. }
  147.  
  148. void Class::Show(char *buf, void *addr, int, bool isptr)
  149. {
  150.     if (isptr) {
  151.     if (ObjectTable::PtrIsValid((Object*)addr))
  152.         sprintf(buf, "<%s>", ((Object*)addr)->ClassName());
  153.     } else
  154.     sprintf(buf, "<inline>");
  155. }
  156.  
  157. OStream &Class::PrintOn(OStream &os)
  158. {
  159.     return os << className SP << version SP;
  160. }
  161.  
  162. // always called on prototype object !!!
  163. Object *Class::ReadAndMap(IStream &is)
  164. {
  165.     char name[40], vers[40];
  166.     
  167.     is >> name >> vers;
  168.     return gClassManager->FindOrLoad(name, vers);
  169. }
  170.  
  171. //---- members -----------------------------------------------------------------
  172.  
  173. Object *Class::SomeMember()
  174. {
  175.     return ObjectTable::SomeMember(this);
  176. }
  177.  
  178. void Class::EnumerateMyMembers(AccessMembers *ac)
  179. {
  180.     if (className && ac)
  181.     ac->ClassName(className);
  182.     if (proto)
  183.     proto->Members(ac);
  184. }
  185.  
  186. void Class::EnumerateMembers(AccessMembers *ac)
  187. {
  188.     EnumerateMyMembers(ac);
  189.     if (super)
  190.     super->EnumerateMembers(ac);
  191. }
  192.  
  193. //---- instance statistics -----------------------------------------------------
  194.  
  195. Object *Class::SomeInstance()
  196. {
  197.     return ObjectTable::SomeInstance(this);
  198. }
  199.  
  200.